// RoyaltyInfo invokes `royaltyInfo` method of contract.
func (c *RoyaltyReader) RoyaltyInfo(tokenID []byte, royaltyToken util.Uint160, salePrice *big.Int) ([]stackitem.Item, error) {
	return unwrap.Array(c.Invoker.Call(c.Hash, "royaltyInfo", tokenID, royaltyToken, salePrice))
}

func TestRoyaltyReaderRoyaltyInfo2(t *testing.T) {
	ta := new(testAct)
	rr := &RoyaltyReader{
		Invoker: ta,
		Hash:    util.Uint160{1, 2, 3},
	}

	tokenID := []byte{1, 2, 3}
	royaltyToken := util.Uint160{4, 5, 6}
	salePrice := big.NewInt(1000)

	tests := []struct {
		name       string
		setupFunc  func()
		expectErr  bool
		expectedRI []RoyaltyRecipient
	}{
		{
			name: "error case",
			setupFunc: func() {
				ta.err = errors.New("some error")
			},
			expectErr: true,
		},
		{
			name: "valid response",
			setupFunc: func() {
				ta.err = nil
				recipient := util.Uint160{7, 8, 9}
				amount := big.NewInt(100)
				ta.res = &result.Invoke{
					State: "HALT",
					Stack: []stackitem.Item{
						stackitem.Make([]stackitem.Item{
							stackitem.Make(recipient.BytesBE()),
							stackitem.Make(amount),
						}),
					},
				}
			},
			expectErr: false,
			expectedRI: []RoyaltyRecipient{
				{
					Address: util.Uint160{7, 8, 9},
					Amount:  big.NewInt(100),
				},
			},
		},
		{
			name: "invalid data response",
			setupFunc: func() {
				ta.res = &result.Invoke{
					State: "HALT",
					Stack: []stackitem.Item{
						stackitem.Make([]stackitem.Item{
							stackitem.Make(util.Uint160{7, 8, 9}.BytesBE()),
						}),
					},
				}
			},
			expectErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.setupFunc()
			riStackItems, err := rr.RoyaltyInfo(tokenID, royaltyToken, salePrice)
			if tt.expectErr {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
				require.Len(t, riStackItems, len(tt.expectedRI))

				var actualRI []RoyaltyRecipient
				for _, item := range riStackItems {
					subItems, ok := item.Value().([]stackitem.Item)
					require.True(t, ok)
					require.Len(t, subItems, 2)

					recipientBytes, err := subItems[0].TryBytes()
					require.NoError(t, err)
					recipient, err := util.Uint160DecodeBytesBE(recipientBytes)
					require.NoError(t, err)

					amount, err := subItems[1].TryInteger()
					require.NoError(t, err)

					actualRI = append(actualRI, RoyaltyRecipient{
						Address: recipient,
						Amount:  amount,
					})
				}

				require.Equal(t, tt.expectedRI, actualRI)
			}
		})
	}
}

=== RUN   TestRoyaltyReaderRoyaltyInfo2/valid_response
    royalty_test.go:183: 
        	Error Trace:	/Users/ekaterinapavlova/Workplace/neo-go/pkg/rpcclient/nep24/royalty_test.go:183
        	Error:      	"[ByteString BigInteger]" should have 1 item(s), but has 2
        	Test:       	TestRoyaltyReaderRoyaltyInfo2/valid_response
--- FAIL: TestRoyaltyReaderRoyaltyInfo2/valid_response (0.00s)

=== RUN   TestRoyaltyReaderRoyaltyInfo2/invalid_data_response
    royalty_test.go:180: 
        	Error Trace:	/Users/ekaterinapavlova/Workplace/neo-go/pkg/rpcclient/nep24/royalty_test.go:180
        	Error:      	An error is expected but got nil.
        	Test:       	TestRoyaltyReaderRoyaltyInfo2/invalid_data_response
--- FAIL: TestRoyaltyReaderRoyaltyInfo2/invalid_data_response (0.00s)